package Excuse.stack;

import Datastruct.stack.ArrayStack;

public class TestStack {
    public static void main(String[] args) {

//        System.out.println(detecation("aba"));
        /**
         * 1.需要遍历字符串，获取每一个字符
         * 2.判断当前字符是一个运算符还是一个数字
         * 3.把数字存放在数字栈中，把运算符放在运算符栈
         * 4.运算符栈：  如果是一个空栈，那么直接运算符入栈，如果运算符栈中已经有其他运算符
         * 就需要先对比运算符的优先级，新进来的运算符如果小于等于原栈中的运算符，那么需要把
         * 原运算符栈弹出来，数字栈中的数字进行弹栈，进行运算，运算后的结果重新放入数字栈中，新运算符入栈
         */
        String str="4+2*3-1";

        StackArray numstack=new StackArray(10);
        StackArray charstack=new StackArray(10);

        int length = str.length();
        String  values="";
        int temp1=0;
        int temp2=0;
        char symbol=0;
        int result=0;
        for(int i=0;i<length;i++){
            //获取每一个数字
            char c=str.charAt(i);
            if(charstack.isOper(c)){    //判断是否是字符
                if(!charstack.isEmpty()){
                    //判断当亲=前字符和字符栈顶字符的优先级，如果优先级小于或者等于，则先运算栈中的字符
                    if(charstack.prority(c)<=charstack.prority((char) charstack.peek())){
                        temp1=numstack.pop();
                        temp2=numstack.pop();
                        symbol= (char) charstack.pop();
                        result=numstack.calculate(temp1,temp2,symbol);

                        numstack.push(result);
                        charstack.push(c);
                    }else {  //优先级大于直接加入
                        charstack.push(c);
                    }
                }else{  //字符栈为空直接加入
                        charstack.push(c);
                    }

            }else {  //不是字符则加入数字栈
                //  33+44
                values+=c;
                if(i==length-1){
                    //如果是最后一个数字  直接加入
                    numstack.push(Integer.parseInt(values));
                }else {
                    //截取下一位判断是否是符号
                    char data = str.substring(i + 1, i + 2).charAt(0);
                    if(charstack.isOper(data)){
                        numstack.push(Integer.parseInt(values));
                        //加完之后要清零
                        values="";
                    }
                }
            }
        }
        while (true){
            if(charstack.isEmpty()){
                break;
            }
            temp1=numstack.pop();
            temp2=numstack.pop();
            symbol= (char) charstack.pop();
            result=numstack.calculate(temp1,temp2,symbol);

            numstack.push(result);
        }
        int res=numstack.pop();
        System.out.println("结果是："+res);


    }
    //判断输入的字符串是否是回文
    public  static  boolean detecation(String str){

        //初始化
        StackArray arrayStack=new StackArray(10);
        int length = str.length();

        //入栈
        for(int i=0;i<length;i++){
            arrayStack.push(str.charAt(i));
        }

        String newstr="";
        int length1 = arrayStack.length();
        for(int i=0;i<length1;i++){
            if(!arrayStack.isEmpty()){
                char value = (char) arrayStack.pop();
                newstr=newstr+value;
            }
        }
        if(str.equals(newstr)){
            return true;
        }

        return  false;

    }
}
